Vasudev Kamath: Writing a UDP Broadcast Receiver as Python Iterator
I had to write a small Python application to listen for some broadcast message
and process the message. This broadcast messages are actually sort of discovery
messages to find some peers in a network. Writing a simple UDP Server to listen
on a particular port was easy; but while designing an application I was
wondering how can I plugin this server into my main code. There are 2
possibility
- Use threading module of python to send the server code in back ground and give it a callback to communicate the data to main thread.
- Periodically read some messages from server code and then dispose of server.
from socket import socket, AF_INET, SOCK_DGRAM
class BroadCastReceiver:
def __init__(self, port, msg_len=8192):
self.sock = socket(AF_INET, SOCK_DGRAM)
self.sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
self.sock.bind(('', port))
self.msg_len = msg_len
def __iter__(self):
return self
def __next__(self):
try:
addr, data = self.sock.recvfrom(self.msg_len)
return addr, data
except Exception as e:
print("Got exception trying to recv %s" % e)
raise StopIteration
...
def __init__(self, port, msg_len=8192, timeout=15):
self.sock = socket(AF_INET, SOCK_DGRAM)
self.sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
self.sock.settimeout(timeout)
self.sock.msg_len = msg_len
self.sock.bind(('', port))
...
...
def __del__(self):
self.sock.close()
r = BroadCastReceiver(5000, timeout=10)
count = 0
for (address, data) in r:
print('Got packet from %s: %s' % address, data)
count += 1
# do whatever you want with data
if count > 10:
break
r = BroadCastReceiver(5000, timeout=10)
for i in range(20):
try:
address, data = next(r)
# do whatever you want with data
except:
break
Update
I got a suggestion from Ryan Nowakowski to make the server object as context
manager and close the socket in __exit__ as it can't be guaranteed that
__del__ will be called for objects which exists during interpreter exits. So I slightly modified the class to add __enter__ and __exit__ method like below and removed __del__
Usage pattern is slightly modified because of this and we need to use with
statement while creating object.
It is also possible to cleanly close socket without adding context manager that
is adding finally statement to our try and except block in __next__. The
modified code without adding context manager looks like below.
When we raise StopIteration again from except block, it will be temporarily
saved and finally block is executed which will now close the socket.
...
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, traceback):
self.sock.close()
with BroadCastReceiver(2000) as r:
# use server object as you wish
...
def __next__(self):
try:
addr, data = self.sock.recvfrom(self.msg_len)
return addr, data
except Exception as e:
print("Got exception trying to recv %s" % e)
raise StopIteration
finally:
self.sock.close()
A good six years ago I 
The code uses a few standard finance packages for R (with most of them maintained by 
Comments and further enhancements welcome!
I've been using a 
Whilst I managed to read almost sixty books in 2016 here are ten of my favourites in no particular order.
Disappointments this year include Stewart Lee's 
The image has been taken from 
The image comes from 
. Who said gluttony is bad
Or this
Authenticating HTTPS clients using TLS certificates has long been very
easy to do. The hardest part, in fact, is to create a PKI infrastructure
robust enough so that compromised (or otherwise no longer desirable)
certificates cannot be used anymore. While setting that up can be fairly
involved, it's all pretty standard practice these days.
But authentication using a private CA is laughably easy. With apache,
you just do something like:
Once again, Ryan Neily and I met last month for our annual hike. This year, to give our aging knees a break, we visited the 
The best known smart bulb setups (such as the Philips Hue and the Belkin Wemo) are based on Zigbee, a low-energy, low-bandwidth protocol that operates on various unlicensed radio bands. The problem with Zigbee is that basically no home routers or mobile devices have a Zigbee radio, so to communicate with them you need an additional device (usually called a hub or bridge) that can speak Zigbee and also hook up to your existing home network. Requests are sent to the hub (either directly if you're on the same network, or via some external control server if you're on a different network) and it sends appropriate Zigbee commands to the bulbs.
Data is from 
What happened in the 
In a few weeks, I will have the opportunity to offer a weekend workshop to selected and motivated high school students
